#define _CRT_SECURE_NO_WARNINGS


//bool _isSymmetric(struct TreeNode* left, struct TreeNode* right)
//{
//    if (left == NULL && right == NULL)
//    {
//        return true;
//    }
//
//    if (left == NULL || right == NULL)
//    {
//        return false;
//    }
//
//    if (left->val != right->val)
//    {
//        return false;
//    }
//
//    return _isSymmetric(left->left, right->right)
//        && _isSymmetric(left->right, right->left);
//}
//
//bool isSymmetric(struct TreeNode* root)
//{
//    if (root == NULL)
//    {
//        return true;
//    }
//
//    return _isSymmetric(root->left, root->right);
//}

#include<stdio.h>
#include<stdlib.h>

//struct TreeNode
//{
//    int val;
//    struct TreeNode* left;
//    struct TreeNode* right;
//};
//
//
//int treeSize(struct TreeNode* root)
//{
//    return root == NULL ? 0 : treeSize(root->left) + treeSize(root->right) + 1;
//}
//
//void _preorderTraversal(struct TreeNode* root, int** ret, int* i)
//{
//    *(*ret + (*i)++) = root->val;
//
//    _preorderTraversal(root->left, ret, i);
//    _preorderTraversal(root->right, ret, i);
//}
//
//int* preorderTraversal(struct TreeNode* root, int* returnSize)
//{
//    if (root == NULL)
//    {
//        return NULL;
//    }
//
//    int treeSZ = treeSize(root);
//    int* ret = (int*)malloc(treeSZ * sizeof(int));
//    int i = 0;
//
//    _preorderTraversal(root, &ret, &i);
//
//    *returnSize = treeSZ;
//    return ret;
//}
//
//int main()
//{
//    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
//    root->right = root->left = NULL;
//    root->val = 1;
//    int i = 0;
//
//    preorderTraversal(root, &i);
//    return 0;
//}

//int treeSize(struct TreeNode* root)
//{
//    return root == NULL ? 0 : treeSize(root->left) + treeSize(root->right) + 1;
//}
//
//void _inorderTraversal(struct TreeNode* root, int** ret, int* i)
//{
//
//    if (root == NULL)
//        return;
//
//    _inorderTraversal(root->left, ret, i);
//    *(*ret + (*i)++) = root->val;
//    _inorderTraversal(root->right, ret, i);
//}
//
//int* inorderTraversal(struct TreeNode* root, int* returnSize)
//{
//    if (root == NULL)
//    {
//        *returnSize = 0;
//        return NULL;
//    }
//
//    int treeSZ = treeSize(root);
//    int* ret = (int*)malloc(treeSZ * sizeof(int));
//    int i = 0;
//
//    _inorderTraversal(root, &ret, &i);
//
//    *returnSize = treeSZ;
//    return ret;
//}


//int treeSize(struct TreeNode* root)
//{
//    return root == NULL ? 0 : treeSize(root->left) + treeSize(root->right) + 1;
//}
//
//void _postorderTraversal(struct TreeNode* root, int** ret, int* i)
//{
//
//    if (root == NULL)
//        return;
//
//    _postorderTraversal(root->left, ret, i);
//    _postorderTraversal(root->right, ret, i);
//    *(*ret + (*i)++) = root->val;
//}
//
//int* postorderTraversal(struct TreeNode* root, int* returnSize)
//{
//    if (root == NULL)
//    {
//        *returnSize = 0;
//        return NULL;
//    }
//
//    int treeSZ = treeSize(root);
//    int* ret = (int*)malloc(treeSZ * sizeof(int));
//    int i = 0;
//
//    _postorderTraversal(root, &ret, &i);
//
//    *returnSize = treeSZ;
//    return ret;
//}

//bool isSameTree(struct TreeNode* root1, struct TreeNode* root2)
//{
//    if (root1 == NULL && root2 == NULL)
//    {
//        return true;
//    }
//
//    if (root1 == NULL || root2 == NULL)
//    {
//        return false;
//    }
//
//    if (root1->val != root2->val)
//    {
//        return false;
//    }
//
//    return isSameTree(root1->left, root2->left)
//        && isSameTree(root1->right, root2->right);
//}
//
//
//bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
//{
//    if (root == NULL)
//    {
//        return false;
//    }
//
//    if (root->val == subRoot->val)
//    {
//        if (isSameTree(root, subRoot))
//            return true;
//    }
//
//    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
//}

//#include <stdio.h>
//#include<stdlib.h>


//TreeNode* buyNode(TreeNodeDataType x)
//{
//    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
//    newNode->data = x;
//    newNode->left = newNode->right = NULL;
//
//    return newNode;
//}
//
//TreeNode* creatTree(char* arr, int* pi)
//{
//    if (arr[*pi] == '#')
//    {
//        (*pi)++;
//        return NULL;
//    }
//
//    TreeNode* root = buyNode(arr[*pi]);
//    (*pi)++;
//    root->left = creatTree(arr, pi);
//    root->right = creatTree(arr, pi);
//
//    return root;
//}
//void inOrder(TreeNode* root)
//{
//    if (root == NULL)
//    {
//        return;
//    }
//
//    inOrder(root->left);
//    printf("%c ", root->data);
//    inOrder(root->right);
//}
//
//int main()
//{
//    char arr[101];
//    scanf("%s", arr);
//    int i = 0;
//
//    TreeNode* root = creatTree(arr, &i);
//
//    inOrder(root);
//    return 0;
//}

#include"Queue.h"

typedef int BTDataType;
typedef struct BinaryTreeNode
{
    BTDataType _data;
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
}BTNode;

bool levelOrder(BTNode* root)
{


    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);

    while (!QueueEmpty(&q))
    {
        BTNode* tmp = QueueFront(&q);
        QueuePop(&q);

        if (tmp)
        {
            QueuePush(&q, tmp->_left);
            QueuePush(&q, tmp->_right);
        }
        else
        {
            break;
        }
    }

    while (!QueueEmpty(&q))
    {
        BTNode* tmp = QueueFront(&q);
        if (tmp)
        {
            return false;
        }
    }

    QueueDestroy(&q);
    return true;
}

//bool BinaryTreeComplete(BTNode* root)
//{   
//
//}

BTNode* BuyNode(BTDataType x)
{
    BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    node->_data = x;
    node->_left = node->_right = NULL;
    return node;
}

BTNode* CreatBinaryTree()
{
    BTNode* node1 = BuyNode(1);
    BTNode* node2 = BuyNode(2);
    BTNode* node3 = BuyNode(3);

    BTNode* node4 = BuyNode(4);
    BTNode* node5 = BuyNode(5);
    BTNode* node6 = BuyNode(6);

    node1->_left = node2;
    node1->_right = node4;
    node2->_left = node3;
    node4->_left = node5;
    node4->_right = node6;
    return node1;
}

int main()
{

    BTNode* root = CreatBinaryTree();

    printf("%d\n", levelOrder(root));

    return 0;
}